// /**
//  * RVO 使用示例
//  * 
//  * @description
//  * 展示如何在 Cocos Creator 3.8 中使用 RVO 动态避障系统
//  */

// import { _decorator, Component, Node, Vec3, Graphics, Color } from 'cc';
// import { Simulator, Vector2 } from './index';
// import { Log } from '../logger/LoggerGlobal';

// const { ccclass, property } = _decorator;

// /**
//  * RVO 管理器
//  * 统一管理所有 RVO 代理的更新
//  */
// @ccclass('RVOManager')
// export class RVOManager extends Component {
    
//     @property
//     enableDebugDraw: boolean = false;
    
//     @property(Graphics)
//     debugGraphics: Graphics | null = null;
    
//     private sim: Simulator = Simulator.instance;
    
//     onLoad(): void {
//         // 初始化 RVO 模拟器
//         this.sim.setAgentDefaults(
//             15,   // neighborDist - 邻居搜索距离
//             10,   // maxNeighbors - 最大邻居数量
//             10,   // timeHorizon - 动态避障时间窗口
//             10,   // timeHorizonObst - 静态避障时间窗口
//             1.5,  // radius - 代理半径
//             2.0,  // maxSpeed - 最大速度
//             new Vector2(0, 0)  // 初始速度
//         );
        
//         Log.ecs.info('RVO 管理器已初始化', {
//             代理数量: this.sim.getNumAgents(),
//             障碍物数量: this.sim.getObstacles().length
//         });
//     }
    
//     update(dt: number): void {
//         // 统一运行 RVO 模拟
//         // 这会计算所有代理的避障速度
//         this.sim.run(dt);
        
//         // 调试绘制
//         if (this.enableDebugDraw && this.debugGraphics) {
//             this.drawDebug();
//         }
//     }
    
//     /**
//      * 调试绘制
//      */
//     private drawDebug(): void {
//         if (!this.debugGraphics) return;
        
//         this.debugGraphics.clear();
        
//         const agentCount = this.sim.getNumAgents();
        
//         for (let i = 0; i < agentCount; i++) {
//             const agentId = this.sim.getAgentAidByIdx(i);
//             const position = this.sim.getAgentPosition(agentId);
//             const velocity = this.sim.getAgentVelocity(agentId);
//             const radius = this.sim.getAgentRadius(agentId);
            
//             if (!position) continue;
            
//             // 绘制代理圆形
//             this.debugGraphics.strokeColor = Color.GREEN;
//             this.debugGraphics.lineWidth = 2;
//             this.debugGraphics.circle(position.x, position.y, radius);
//             this.debugGraphics.stroke();
            
//             // 绘制速度向量
//             this.debugGraphics.strokeColor = Color.RED;
//             this.debugGraphics.lineWidth = 2;
//             this.debugGraphics.moveTo(position.x, position.y);
//             this.debugGraphics.lineTo(
//                 position.x + velocity.x * 10,
//                 position.y + velocity.y * 10
//             );
//             this.debugGraphics.stroke();
//         }
        
//         // 绘制障碍物
//         const obstacles = this.sim.getObstacles();
//         for (const obstacle of obstacles) {
//             if (!obstacle.next) continue;
            
//             this.debugGraphics.strokeColor = Color.BLUE;
//             this.debugGraphics.lineWidth = 3;
//             this.debugGraphics.moveTo(obstacle.point.x, obstacle.point.y);
//             this.debugGraphics.lineTo(obstacle.next.point.x, obstacle.next.point.y);
//             this.debugGraphics.stroke();
//         }
//     }
    
//     onDestroy(): void {
//         // 清理所有代理
//         this.sim.clear();
//         Log.ecs.info('RVO 管理器已清理');
//     }
// }

// /**
//  * RVO 单位
//  * 挂载到需要避障的游戏对象上
//  */
// @ccclass('RVOUnit')
// export class RVOUnit extends Component {
    
//     @property
//     agentId: number = -1;
    
//     @property(Node)
//     target: Node | null = null;
    
//     @property
//     maxSpeed: number = 2.0;
    
//     @property
//     radius: number = 1.5;
    
//     @property
//     mass: number = 1.0;
    
//     @property
//     arrivalDistance: number = 1.0;
    
//     private sim: Simulator = Simulator.instance;
//     private reachedTarget: boolean = false;
    
//     onLoad(): void {
//         // 添加代理到 RVO 模拟器
//         const pos = this.node.position;
        
//         this.agentId = this.sim.addAgent(
//             new Vector2(pos.x, pos.z),  // 使用 x, z 作为 2D 平面
//             this.radius,
//             this.maxSpeed,
//             new Vector2(0, 0),
//             this.mass
//         );
        
//         Log.ecs.info(`单位已添加到 RVO`, {
//             ID: this.agentId,
//             位置: `(${pos.x}, ${pos.z})`,
//             半径: this.radius,
//             最大速度: this.maxSpeed
//         });
//     }
    
//     update(dt: number): void {
//         if (this.agentId === -1) return;
        
//         // 1. 获取当前位置
//         const position = this.sim.getAgentPosition(this.agentId);
//         if (!position) return;
        
//         // 2. 计算朝向目标的期望速度
//         if (this.target && !this.reachedTarget) {
//             const targetPos = this.target.position;
//             const goal = new Vector2(targetPos.x, targetPos.z);
//             const direction = goal.minus(position);
//             const distance = direction.length();
            
//             if (distance > this.arrivalDistance) {
//                 // 设置期望速度
//                 const prefVelocity = direction.normalize().scale(this.maxSpeed);
//                 this.sim.setAgentPrefVelocity(this.agentId, prefVelocity);
//             } else {
//                 // 到达目标，停止
//                 this.sim.setAgentPrefVelocity(this.agentId, new Vector2(0, 0));
//                 this.reachedTarget = true;
                
//                 Log.ecs.info(`单位到达目标`, { ID: this.agentId });
//             }
//         }
        
//         // 3. 获取避障后的实际速度并更新位置
//         const velocity = this.sim.getAgentVelocity(this.agentId);
        
//         const newPos = new Vec3(
//             position.x + velocity.x * dt,
//             this.node.position.y,
//             position.z + velocity.y * dt
//         );
        
//         this.node.setPosition(newPos);
        
//         // 4. 更新朝向（可选）
//         if (velocity.lengthSqr() > 0.01) {
//             const angle = Math.atan2(velocity.y, velocity.x) * 180 / Math.PI;
//             this.node.setRotationFromEuler(0, -angle + 90, 0);
//         }
//     }
    
//     /**
//      * 设置新目标
//      */
//     setTarget(target: Node): void {
//         this.target = target;
//         this.reachedTarget = false;
//     }
    
//     /**
//      * 立即移动到指定位置
//      */
//     teleportTo(x: number, z: number): void {
//         if (this.agentId === -1) return;
        
//         // 注意：RVO 不支持直接设置位置
//         // 需要移除并重新添加代理
//         this.sim.removeAgent(this.agentId);
        
//         this.agentId = this.sim.addAgent(
//             new Vector2(x, z),
//             this.radius,
//             this.maxSpeed,
//             new Vector2(0, 0),
//             this.mass
//         );
        
//         this.node.setPosition(x, this.node.position.y, z);
//     }
    
//     onDestroy(): void {
//         // 移除代理
//         if (this.agentId !== -1) {
//             this.sim.removeAgent(this.agentId);
//             Log.ecs.info(`单位已从 RVO 移除`, { ID: this.agentId });
//         }
//     }
// }

// /**
//  * RVO 巡逻单位
//  * 沿着多个路点巡逻
//  */
// @ccclass('RVOPatrolUnit')
// export class RVOPatrolUnit extends RVOUnit {
    
//     @property([Node])
//     patrolPoints: Node[] = [];
    
//     @property
//     loopPatrol: boolean = true;
    
//     private currentPatrolIndex: number = 0;
    
//     start(): void {
//         if (this.patrolPoints.length > 0) {
//             this.setTarget(this.patrolPoints[0]);
//         }
//     }
    
//     update(dt: number): void {
//         // 调用父类更新
//         super.update(dt);
        
//         // 检查是否到达当前巡逻点
//         if (this.reachedTarget && this.patrolPoints.length > 0) {
//             this.moveToNextPatrolPoint();
//         }
//     }
    
//     /**
//      * 移动到下一个巡逻点
//      */
//     private moveToNextPatrolPoint(): void {
//         this.currentPatrolIndex++;
        
//         if (this.currentPatrolIndex >= this.patrolPoints.length) {
//             if (this.loopPatrol) {
//                 this.currentPatrolIndex = 0;
//             } else {
//                 // 到达终点，停止巡逻
//                 return;
//             }
//         }
        
//         this.setTarget(this.patrolPoints[this.currentPatrolIndex]);
//     }
// }

// /**
//  * RVO 障碍物构建器
//  * 将 Cocos 节点转换为 RVO 障碍物
//  */
// @ccclass('RVOObstacleBuilder')
// export class RVOObstacleBuilder extends Component {
    
//     @property([Node])
//     obstacleNodes: Node[] = [];
    
//     @property
//     obstacleRadius: number = 10;
    
//     @property
//     obstacleSegments: number = 8;
    
//     private sim: Simulator = Simulator.instance;
    
//     start(): void {
//         this.buildObstacles();
//     }
    
//     /**
//      * 构建障碍物
//      */
//     buildObstacles(): void {
//         for (const node of this.obstacleNodes) {
//             this.addCircleObstacle(node.position.x, node.position.z, this.obstacleRadius);
//         }
        
//         // 构建障碍物 KD-Tree
//         this.sim.processObstacles();
        
//         Log.ecs.info('RVO 障碍物已构建', {
//             数量: this.obstacleNodes.length,
//             总障碍物: this.sim.getObstacles().length
//         });
//     }
    
//     /**
//      * 添加圆形障碍物
//      */
//     private addCircleObstacle(x: number, z: number, radius: number): void {
//         const vertices: Vector2[] = [];
        
//         for (let i = 0; i < this.obstacleSegments; i++) {
//             const angle = (i / this.obstacleSegments) * Math.PI * 2;
//             vertices.push(new Vector2(
//                 x + Math.cos(angle) * radius,
//                 z + Math.sin(angle) * radius
//             ));
//         }
        
//         this.sim.addObstacle(vertices);
//     }
    
//     /**
//      * 添加矩形障碍物
//      */
//     addRectObstacle(x: number, z: number, width: number, height: number): void {
//         const halfW = width / 2;
//         const halfH = height / 2;
        
//         const vertices: Vector2[] = [
//             new Vector2(x - halfW, z - halfH),  // 左下
//             new Vector2(x + halfW, z - halfH),  // 右下
//             new Vector2(x + halfW, z + halfH),  // 右上
//             new Vector2(x - halfW, z + halfH)   // 左上
//         ];
        
//         this.sim.addObstacle(vertices);
//         this.sim.processObstacles();
//     }
// }

// /**
//  * RVO 测试场景
//  * 创建多个单位进行避障测试
//  */
// @ccclass('RVOTestScene')
// export class RVOTestScene extends Component {
    
//     @property(Node)
//     unitPrefab: Node | null = null;
    
//     @property
//     unitCount: number = 20;
    
//     @property
//     spawnRadius: number = 100;
    
//     @property(Node)
//     targetNode: Node | null = null;
    
//     private units: Node[] = [];
    
//     start(): void {
//         this.spawnUnits();
//     }
    
//     /**
//      * 生成测试单位
//      */
//     private spawnUnits(): void {
//         if (!this.unitPrefab) return;
        
//         for (let i = 0; i < this.unitCount; i++) {
//             // 随机生成位置（圆形分布）
//             const angle = Math.random() * Math.PI * 2;
//             const distance = Math.random() * this.spawnRadius;
//             const x = Math.cos(angle) * distance;
//             const z = Math.sin(angle) * distance;
            
//             // 创建单位
//             const unit = instantiate(this.unitPrefab);
//             unit.setParent(this.node);
//             unit.setPosition(x, 0, z);
            
//             // 设置目标
//             const unitComp = unit.getComponent(RVOUnit);
//             if (unitComp && this.targetNode) {
//                 unitComp.target = this.targetNode;
//             }
            
//             this.units.push(unit);
//         }
        
//         Log.ecs.info(`RVO 测试场景已生成`, {
//             单位数量: this.unitCount
//         });
//     }
    
//     /**
//      * 更换目标位置
//      */
//     changeTarget(x: number, z: number): void {
//         if (!this.targetNode) return;
        
//         this.targetNode.setPosition(x, 0, z);
        
//         Log.ecs.info('目标位置已更新', { x, z });
//     }
// }

// // 辅助函数
// function instantiate(prefab: Node): Node {
//     // 简化实现，实际应该使用 Cocos 的 instantiate
//     return prefab.clone();
// }

